Spiff up xmlgeneric enough to work with wfff, but needs rething on attributes.

Teaching callers about qxmlstreamattributes may be "better" than shimming this
to QStrings.

diff --git a/gpsbabel/xmlgeneric.cc b/gpsbabel/xmlgeneric.cc
index 40d09d2f18bb43c78755ad375b69c321192e0fca..b526581798d8138924fda32703467211840552b2 100644 (file)
--- a/gpsbabel/xmlgeneric.cc
+++ b/gpsbabel/xmlgeneric.cc
@@ -38,19 +38,19 @@ static XML_Parser psr;
 
 static QString current_tag;
 static vmem_t cdatastr;
-static gbfile *ifd;
-static xg_tag_mapping *xg_tag_tbl;
-static const char **xg_ignore_taglist;
+static gbfile* ifd;
+static xg_tag_mapping* xg_tag_tbl;
+static const char** xg_ignore_taglist;
 
 #define MY_CBUF 4096
 
 #define MYNAME "XML Reader"
 
 void
-write_xml_header(gbfile *ofd)
+write_xml_header(gbfile* ofd)
 {
   char buff[128];
-  cet_cs_vec_t *cs = cet_find_cs_by_name(CET_CHARSET_ASCII);
+  cet_cs_vec_t* cs = cet_find_cs_by_name(CET_CHARSET_ASCII);
 
   if ((global_opts.charset != NULL) && (global_opts.charset != cs)) {
     snprintf(buff, sizeof(buff), " encoding=\"%s\"", global_opts.charset_name);
@@ -61,16 +61,16 @@ write_xml_header(gbfile *ofd)
 }
 
 void
-write_xml_entity(gbfile *ofd, const QString& indent,
+write_xml_entity(gbfile* ofd, const QString& indent,
                  const QString& tag, const QString& value)
 {
-  char *tmp_ent = xml_entitize(value.toLatin1().data());
+  char* tmp_ent = xml_entitize(value.toLatin1().data());
   gbfprintf(ofd, "%s<%s>%s</%s>\n", qPrintable(indent), qPrintable(tag), tmp_ent, qPrintable(tag));
   xfree(tmp_ent);
 }
 
 void
-write_optional_xml_entity(gbfile *ofd, const QString& indent,
+write_optional_xml_entity(gbfile* ofd, const QString& indent,
                           const QString& tag, const QString& value)
 {
   if (!value.isEmpty()) {
@@ -79,14 +79,14 @@ write_optional_xml_entity(gbfile *ofd, const QString& indent,
 }
 
 void
-write_xml_entity_begin0(gbfile *ofd, const QString& indent,
+write_xml_entity_begin0(gbfile* ofd, const QString& indent,
                         const QString& tag)
 {
   gbfprintf(ofd, "%s<%s>\n", indent.toLatin1().data(), tag.toLatin1().data());
 }
 
 void
-write_xml_entity_begin1(gbfile *ofd, const QString& indent,
+write_xml_entity_begin1(gbfile* ofd, const QString& indent,
                         const QString& tag, const QString& attr,
                         const QString& attrval)
 {
@@ -94,7 +94,7 @@ write_xml_entity_begin1(gbfile *ofd, const QString& indent,
 }
 
 void
-write_xml_entity_begin2(gbfile *ofd, const QString& indent,
+write_xml_entity_begin2(gbfile* ofd, const QString& indent,
                         const QString& tag, const QString& attr1,
                         const QString& attrval1, const QString& attr2,
                         const QString& attrval2)
@@ -103,14 +103,14 @@ write_xml_entity_begin2(gbfile *ofd, const QString& indent,
 }
 
 void
-write_xml_entity_end(gbfile *ofd, const QString& indent,
+write_xml_entity_end(gbfile* ofd, const QString& indent,
                      const QString& tag)
 {
   gbfprintf(ofd, "%s</%s>\n", indent.toLatin1().data(), tag.toLatin1().data());
 }
 
 void
-xml_write_time(gbfile *ofd, gpsbabel::DateTime dt, const char *elname)
+xml_write_time(gbfile* ofd, gpsbabel::DateTime dt, const char* elname)
 {
   gbfprintf(ofd, "<%s>%s</%s>\n",
             elname,
@@ -129,10 +129,10 @@ xml_write_time(gbfile *ofd, gpsbabel::DateTime dt, const char *elname)
  * xml strains and insulates us from a lot of the grubbiness of expat.
  */
 
-xg_callback *
+xg_callback*
 xml_tbl_lookup(const QString& tag, xg_cb_type cb_type)
 {
-  xg_tag_mapping *tm;
+  xg_tag_mapping* tm;
   for (tm = xg_tag_tbl; tm->tag_cb != NULL; tm++) {
     if (str_match(tag.toUtf8().data(), tm->tag_name) && (cb_type == tm->cb_type)) {
       return tm->tag_cb;
@@ -146,9 +146,9 @@ xml_tbl_lookup(const QString& tag, xg_cb_type cb_type)
  * Returns 0 if it is not on the list.
  */
 static int
-xml_consider_ignoring(const char *t)
+xml_consider_ignoring(const char* t)
 {
-  const char **il;
+  const char** il;
 
   if (!xg_ignore_taglist) {
     return 0;
@@ -164,11 +164,11 @@ xml_consider_ignoring(const char *t)
 
 
 static void
-xml_start(void *data, const XML_Char *xml_el, const XML_Char **xml_attr)
+xml_start(void* data, const XML_Char* xml_el, const XML_Char** xml_attr)
 {
-  xg_callback *cb;
-  const char *el;
-  const char **attrs;
+  xg_callback* cb;
+  const char* el;
+  const char** attrs;
 
   el = xml_convert_to_char_string(xml_el);
   attrs = xml_convert_attrs_to_char_string(xml_attr);
@@ -195,25 +195,25 @@ xml_start(void *data, const XML_Char *xml_el, const XML_Char **xml_attr)
 
 #if 1
 static void
-xml_cdata(void *dta, const XML_Char *xml_s, int len)
+xml_cdata(void* dta, const XML_Char* xml_s, int len)
 {
-  char *estr;
-  const char *s = xml_convert_to_char_string_n(xml_s, &len);
+  char* estr;
+  const char* s = xml_convert_to_char_string_n(xml_s, &len);
 
   vmem_realloc(&cdatastr,  1 + len + strlen(cdatastr.mem));
-  estr = (char *) cdatastr.mem + strlen(cdatastr.mem);
+  estr = (char*) cdatastr.mem + strlen(cdatastr.mem);
   memcpy(estr, s, len);
   estr[len]  = 0;
   xml_free_converted_string(s);
 }
 
 static void
-xml_end(void *data, const XML_Char *xml_el)
+xml_end(void* data, const XML_Char* xml_el)
 {
   int pos = current_tag.lastIndexOf('/');
   QString s = current_tag.mid(pos + 1);
-  const char *el = xml_convert_to_char_string(xml_el);
-  xg_callback *cb;
+  const char* el = xml_convert_to_char_string(xml_el);
+  xg_callback* cb;
 
   if (xml_consider_ignoring(el)) {
     return;
@@ -227,7 +227,7 @@ xml_end(void *data, const XML_Char *xml_el)
 #endif
   cb = xml_tbl_lookup(current_tag, cb_cdata);
   if (cb) {
-    (*cb)((char *) cdatastr.mem, NULL);
+    (*cb)((char*) cdatastr.mem, NULL);
   }
 
   cb = xml_tbl_lookup(current_tag, cb_end);
@@ -244,9 +244,9 @@ void xml_read(void)
   char buf[MY_CBUF];
 
   while ((len = gbfread(buf, 1, sizeof(buf), ifd))) {
-    char *str = buf;
+    char* str = buf;
     if (ifd->unicode) {
-      str = cet_str_uni_to_utf8((short *)&buf, len >> 1);
+      str = cet_str_uni_to_utf8((short*)&buf, len >> 1);
       len = strlen(str);
     }
     if (!XML_Parse(psr, str, len, gbfeof(ifd))) {
@@ -262,7 +262,7 @@ void xml_read(void)
 
 }
 
-void xml_readstring(char *str)
+void xml_readstring(char* str)
 {
   int len = strlen(str);
   if (!XML_Parse(psr, str, len, 1)) {
@@ -273,7 +273,7 @@ void xml_readstring(char *str)
   XML_ParserFree(psr);
 }
 
-void xml_readprefixstring(const char *str)
+void xml_readprefixstring(const char* str)
 {
   int len = strlen(str);
   if (!XML_Parse(psr, str, len, 0)) {
@@ -283,13 +283,13 @@ void xml_readprefixstring(const char *str)
   }
 }
 
-void xml_ignore_tags(const char **taglist)
+void xml_ignore_tags(const char** taglist)
 {
   xg_ignore_taglist = taglist;
 }
 
 void
-xml_init0(const char *fname, xg_tag_mapping *tbl, const char *encoding,
+xml_init0(const char* fname, xg_tag_mapping* tbl, const char* encoding,
           gbsize_t offset)
 {
   if (fname) {
@@ -303,13 +303,13 @@ xml_init0(const char *fname, xg_tag_mapping *tbl, const char *encoding,
 
   current_tag.clear();
 
-  psr = XML_ParserCreate((const XML_Char *)encoding);
+  psr = XML_ParserCreate((const XML_Char*)encoding);
   if (!psr) {
     fatal(MYNAME ": Cannot create XML Parser\n");
   }
 
   cdatastr = vmem_alloc(1, 0);
-  *((char *)cdatastr.mem) = '\0';
+  *((char*)cdatastr.mem) = '\0';
 
   xg_tag_tbl = tbl;
 
@@ -322,13 +322,13 @@ xml_init0(const char *fname, xg_tag_mapping *tbl, const char *encoding,
 
 /* xml_init0 iwth a default seek argument of zero */
 void
-xml_init(const char *fname, xg_tag_mapping *tbl, const char *encoding)
+xml_init(const char* fname, xg_tag_mapping* tbl, const char* encoding)
 {
   xml_init0(fname, tbl, encoding, 0);
 }
 
 void
-xml_init_offset(const char *fname, xg_tag_mapping *tbl, const char *encoding,
+xml_init_offset(const char* fname, xg_tag_mapping* tbl, const char* encoding,
                 gbsize_t offset)
 {
   xml_init0(fname, tbl, encoding, offset);
@@ -347,11 +347,11 @@ xml_deinit(void)
 
 #else
 
-static const char *rd_fname;
+static const char* rd_fname;
 static QXmlStreamReader reader;
 
 void
-xml_init(const char *fname, xg_tag_mapping *tbl, const char *encoding)
+xml_init(const char* fname, xg_tag_mapping* tbl, const char* encoding)
 {
   rd_fname = fname;
   xg_tag_tbl = tbl;
@@ -365,50 +365,51 @@ void xml_read(void)
 
   QString current_tag;
   while (!reader.atEnd()) {
-    xg_callback *cb = xml_tbl_lookup(current_tag, cb_start);
     switch (reader.tokenType()) {
-      case QXmlStreamReader::StartElement: {
-        if (cb) {
-          const char **attrs;
-          (*cb)(NULL, attrs);
-        }
-        current_tag.append("/");
-        current_tag.append(reader.name());
-        cb = xml_tbl_lookup(current_tag, cb_cdata);
-        if (cb) {
-          QString c = reader.readElementText();
-          (*cb)(c.toUtf8().data(), NULL);
-          current_tag.chop(reader.name().length() + 1);
-        }
-        }
-        break;
-      case QXmlStreamReader::Characters:
-        break;
-      case QXmlStreamReader::EndElement:
-        cb = xml_tbl_lookup(current_tag, cb_end);
-        if (cb) {
-          (*cb)(NULL, NULL);
-        }
+    case QXmlStreamReader::StartElement: {
+      current_tag.append("/");
+      current_tag.append(reader.name());
+      xg_callback* cb = xml_tbl_lookup(current_tag, cb_start);
+      if (cb) {
+        const char** attrs;
+        (*cb)(NULL, attrs);
+      }
+      cb = xml_tbl_lookup(current_tag, cb_cdata);
+      if (cb) {
+        QString c = reader.readElementText();
+        (*cb)(c.toUtf8().data(), NULL);
         current_tag.chop(reader.name().length() + 1);
-        break;
-      default:
-        break;
+      }
+    }
+    break;
+    case QXmlStreamReader::Characters:
+      break;
+    case QXmlStreamReader::EndElement: {
+      xg_callback* cb = xml_tbl_lookup(current_tag, cb_end);
+      if (cb) {
+        (*cb)(NULL, NULL);
+      }
+      current_tag.chop(reader.name().length() + 1);
+    }
+    break;
+    default:
+      break;
     };
     reader.readNextStartElement();
   }
 
 }
 
-void xml_ignore_tags(const char **taglist)
+void xml_ignore_tags(const char** taglist)
 {
   xg_ignore_taglist = taglist;
 }
 
-void xml_readprefixstring(const char *str)
+void xml_readprefixstring(const char* str)
 {
 }
 
-void xml_readstring(char *str)
+void xml_readstring(char* str)
 {
 }